package com.geekchique.runningbuddy.model;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.LinkedHashMap;

public class StubCalendarMonthsForPastJogsTable {
	
	public static LinkedHashMap<Integer, Integer> getAMonthIn2008(int month){
		switch(month){
			case 0: return january08table();
			case 1: return february08table();
			case 2: return march08table();
			case 3: return april08table();
			case 4: return may08table();
			case 5: return june08table();
			case 6: return july08table();
			case 7: return august08table();
			case 8: return september08table();
			case 9: return october08table();
			case 10: return november08table();
			case 11: return december08table();
		}
		
		return null;
	}
	
	
	public static ArrayList<LinkedHashMap<Integer, Integer>> monthsIn2008(){
		
		ArrayList<LinkedHashMap<Integer, Integer>> monthsIn2008 = new ArrayList<LinkedHashMap<Integer, Integer>>();
		
		monthsIn2008.add(january08table());
		monthsIn2008.add(february08table());
		monthsIn2008.add(march08table());
		monthsIn2008.add(april08table());
		monthsIn2008.add(may08table());
		monthsIn2008.add(june08table());
		monthsIn2008.add(july08table());
		monthsIn2008.add(august08table());
		monthsIn2008.add(october08table());
		monthsIn2008.add(september08table());
		monthsIn2008.add(november08table());
		monthsIn2008.add(december08table());
		
		return monthsIn2008;
	}
	
	
	
	public static LinkedHashMap<Integer, Integer> january08table(){
		
		LinkedHashMap<Integer, Integer> jan08Set = new LinkedHashMap<Integer, Integer>();
		jan08Set.put(0, 0);
		jan08Set.put(1, 1);
		jan08Set.put(2, 2);
		jan08Set.put(3, 3);
		jan08Set.put(4, 4);
		jan08Set.put(5, 5);
		jan08Set.put(6, 6);
		jan08Set.put(10, 7);
		jan08Set.put(11, 8);
		jan08Set.put(12, 9);
		jan08Set.put(13, 10);
		jan08Set.put(14, 11);
		jan08Set.put(15, 12);
		jan08Set.put(16, 13);
		jan08Set.put(20, 14);
		jan08Set.put(21, 15);
		jan08Set.put(22, 16);
		jan08Set.put(23, 17);
		jan08Set.put(24, 18);
		jan08Set.put(25, 19);
		jan08Set.put(26, 20);
		jan08Set.put(30, 21);
		jan08Set.put(31, 22);
		jan08Set.put(32, 23);
		jan08Set.put(33, 24);
		jan08Set.put(34, 25);
		jan08Set.put(35, 26);
		jan08Set.put(36, 27);
		jan08Set.put(40, 28);
		jan08Set.put(41, 29);
		jan08Set.put(42, 30);
		jan08Set.put(43, 31);
		jan08Set.put(44, 00);
		jan08Set.put(45, 00);
		jan08Set.put(46, 00);
		jan08Set.put(50, 00);
		jan08Set.put(51, 00);
		jan08Set.put(52, 00);
		jan08Set.put(53, 00);
		jan08Set.put(54, 00);
		jan08Set.put(55, 00);
		jan08Set.put(56, 00);

		return jan08Set;
	}
	
	public static  LinkedHashMap<Integer, Integer> february08table(){
		
		LinkedHashMap<Integer, Integer> feb08Table = new LinkedHashMap<Integer, Integer>();
		feb08Table.put(0, 00);
		feb08Table.put(1, 00);
		feb08Table.put(2, 00);
		feb08Table.put(3, 00);
		feb08Table.put(4, 1);
		feb08Table.put(5, 2);
		feb08Table.put(6, 3);
		feb08Table.put(10, 4);
		feb08Table.put(11, 5);
		feb08Table.put(12, 6);
		feb08Table.put(13, 7);
		feb08Table.put(14, 8);
		feb08Table.put(15, 9);
		feb08Table.put(16, 10);
		feb08Table.put(20, 11);
		feb08Table.put(21, 12);
		feb08Table.put(22, 13);
		feb08Table.put(23, 14);
		feb08Table.put(24, 15);
		feb08Table.put(25, 16);
		feb08Table.put(26, 17);
		feb08Table.put(30, 18);
		feb08Table.put(31, 19);
		feb08Table.put(32, 20);
		feb08Table.put(33, 21);
		feb08Table.put(34, 22);
		feb08Table.put(35, 23);
		feb08Table.put(36, 24);
		feb08Table.put(40, 25);
		feb08Table.put(41, 26);
		feb08Table.put(42, 27);
		feb08Table.put(43, 28);
		feb08Table.put(44, 29);
		feb08Table.put(45, 00);
		feb08Table.put(46, 00);
		feb08Table.put(50, 00);
		feb08Table.put(51, 00);
		feb08Table.put(52, 00);
		feb08Table.put(53, 00);
		feb08Table.put(54, 00);
		feb08Table.put(55, 00);
		feb08Table.put(56, 00);
		
		return feb08Table;
	}
	
	public static  LinkedHashMap<Integer, Integer> march08table(){
		
		LinkedHashMap<Integer, Integer> march08Table = new LinkedHashMap<Integer, Integer>();
		march08Table.put(0, 0);
		march08Table.put(1, 0);
		march08Table.put(2, 0);
		march08Table.put(3, 0);
		march08Table.put(4, 0);
		march08Table.put(5, 1);
		march08Table.put(6, 2);
		march08Table.put(10, 3);
		march08Table.put(11, 4);
		march08Table.put(12, 5);
		march08Table.put(13, 6);
		march08Table.put(14, 7);
		march08Table.put(15, 8);
		march08Table.put(16, 9);
		march08Table.put(20, 10);
		march08Table.put(21, 11);
		march08Table.put(22, 12);
		march08Table.put(23, 13);
		march08Table.put(24, 14);
		march08Table.put(25, 15);
		march08Table.put(26, 16);
		march08Table.put(30, 17);
		march08Table.put(31, 18);
		march08Table.put(32, 19);
		march08Table.put(33, 20);
		march08Table.put(34, 21);
		march08Table.put(35, 22);
		march08Table.put(36, 23);
		march08Table.put(40, 24);
		march08Table.put(41, 25);
		march08Table.put(42, 26);
		march08Table.put(43, 27);
		march08Table.put(44, 28);
		march08Table.put(45, 29);
		march08Table.put(46, 30);
		march08Table.put(50, 31);
		march08Table.put(51, 00);
		march08Table.put(52, 00);
		march08Table.put(53, 00);
		march08Table.put(54, 00);
		march08Table.put(55, 00);
		march08Table.put(56, 00);
		
		return march08Table;
	}
	
	public static  LinkedHashMap<Integer, Integer> april08table(){
		
		LinkedHashMap<Integer, Integer> april08Table = new LinkedHashMap<Integer, Integer>();
		april08Table.put(0, 0);
		april08Table.put(1, 1);
		april08Table.put(2, 2);
		april08Table.put(3, 3);
		april08Table.put(4, 4);
		april08Table.put(5, 5);
		april08Table.put(6, 6);
		april08Table.put(10, 7);
		april08Table.put(11, 8);
		april08Table.put(12, 9);
		april08Table.put(13, 10);
		april08Table.put(14, 11);
		april08Table.put(15, 12);
		april08Table.put(16, 13);
		april08Table.put(20, 14);
		april08Table.put(21, 15);
		april08Table.put(22, 16);
		april08Table.put(23, 17);
		april08Table.put(24, 18);
		april08Table.put(25, 19);
		april08Table.put(26, 20);
		april08Table.put(30, 21);
		april08Table.put(31, 22);
		april08Table.put(32, 23);
		april08Table.put(33, 24);
		april08Table.put(34, 25);
		april08Table.put(35, 26);
		april08Table.put(36, 27);
		april08Table.put(40, 28);
		april08Table.put(41, 29);
		april08Table.put(42, 30);
		april08Table.put(43, 00);
		april08Table.put(44, 00);
		april08Table.put(45, 00);
		april08Table.put(46, 00);
		april08Table.put(50, 00);
		april08Table.put(51, 00);
		april08Table.put(52, 00);
		april08Table.put(53, 00);
		april08Table.put(54, 00);
		april08Table.put(55, 00);
		april08Table.put(56, 00);
		
		return april08Table;
	}
	
	public static  LinkedHashMap<Integer, Integer> may08table(){
		
		LinkedHashMap<Integer, Integer> may08Table = new LinkedHashMap<Integer, Integer>();
		may08Table.put(0, 0);
		may08Table.put(1, 0);
		may08Table.put(2, 0);
		may08Table.put(3, 1);
		may08Table.put(4, 2);
		may08Table.put(5, 3);
		may08Table.put(6, 4);
		may08Table.put(10, 5);
		may08Table.put(11, 6);
		may08Table.put(12, 7);
		may08Table.put(13, 8);
		may08Table.put(14, 9);
		may08Table.put(15, 10);
		may08Table.put(16, 11);
		may08Table.put(20, 12);
		may08Table.put(21, 13);
		may08Table.put(22, 14);
		may08Table.put(23, 15);
		may08Table.put(24, 16);
		may08Table.put(25, 17);
		may08Table.put(26, 18);
		may08Table.put(30, 19);
		may08Table.put(31, 20);
		may08Table.put(32, 21);
		may08Table.put(33, 22);
		may08Table.put(34, 23);
		may08Table.put(35, 24);
		may08Table.put(36, 25);
		may08Table.put(40, 26);
		may08Table.put(41, 27);
		may08Table.put(42, 28);
		may08Table.put(43, 29);
		may08Table.put(44, 30);
		may08Table.put(45, 31);
		may08Table.put(46, 00);
		may08Table.put(50, 00);
		may08Table.put(51, 00);
		may08Table.put(52, 00);
		may08Table.put(53, 00);
		may08Table.put(54, 00);
		may08Table.put(55, 00);
		may08Table.put(56, 00);
		
		return may08Table;
	}
	
	public static  LinkedHashMap<Integer, Integer> june08table(){
		
		LinkedHashMap<Integer, Integer> june08Table = new LinkedHashMap<Integer, Integer>();
		june08Table.put(0, 0);
		june08Table.put(1, 0);
		june08Table.put(2, 0);
		june08Table.put(3, 0);
		june08Table.put(4, 0);
		june08Table.put(5, 0);
		june08Table.put(6, 1);
		june08Table.put(10, 2);
		june08Table.put(11, 3);
		june08Table.put(12, 4);
		june08Table.put(13, 5);
		june08Table.put(14, 6);
		june08Table.put(15, 7);
		june08Table.put(16, 8);
		june08Table.put(20, 9);
		june08Table.put(21, 10);
		june08Table.put(22, 11);
		june08Table.put(23, 12);
		june08Table.put(24, 13);
		june08Table.put(25, 14);
		june08Table.put(26, 15);
		june08Table.put(30, 16);
		june08Table.put(31, 17);
		june08Table.put(32, 18);
		june08Table.put(33, 19);
		june08Table.put(34, 20);
		june08Table.put(35, 21);
		june08Table.put(36, 22);
		june08Table.put(40, 23);
		june08Table.put(41, 24);
		june08Table.put(42, 25);
		june08Table.put(43, 26);
		june08Table.put(44, 27);
		june08Table.put(45, 28);
		june08Table.put(46, 29);
		june08Table.put(50, 30);
		june08Table.put(51, 00);
		june08Table.put(52, 00);
		june08Table.put(53, 00);
		june08Table.put(54, 00);
		june08Table.put(55, 00);
		june08Table.put(56, 00);
		
		return june08Table;
	}
	
	public static LinkedHashMap<Integer, Integer> july08table(){
		
		LinkedHashMap<Integer, Integer> july08Table = new LinkedHashMap<Integer, Integer>();
		july08Table.put(0, 0);
		july08Table.put(1, 1);
		july08Table.put(2, 2);
		july08Table.put(3, 3);
		july08Table.put(4, 4);
		july08Table.put(5, 5);
		july08Table.put(6, 6);
		july08Table.put(10, 7);
		july08Table.put(11, 8);
		july08Table.put(12, 9);
		july08Table.put(13, 10);
		july08Table.put(14, 11);
		july08Table.put(15, 12);
		july08Table.put(16, 13);
		july08Table.put(20, 14);
		july08Table.put(21, 15);
		july08Table.put(22, 16);
		july08Table.put(23, 17);
		july08Table.put(24, 18);
		july08Table.put(25, 19);
		july08Table.put(26, 20);
		july08Table.put(30, 21);
		july08Table.put(31, 22);
		july08Table.put(32, 23);
		july08Table.put(33, 24);
		july08Table.put(34, 25);
		july08Table.put(35, 26);
		july08Table.put(36, 27);
		july08Table.put(40, 28);
		july08Table.put(41, 29);
		july08Table.put(42, 30);
		july08Table.put(43, 31);
		july08Table.put(44, 00);
		july08Table.put(45, 00);
		july08Table.put(46, 00);
		july08Table.put(50, 00);
		july08Table.put(51, 00);
		july08Table.put(52, 00);
		july08Table.put(53, 00);
		july08Table.put(54, 00);
		july08Table.put(55, 00);
		july08Table.put(56, 00);
		
		return july08Table;
	}
	
	public static LinkedHashMap<Integer, Integer> august08table(){
		
		LinkedHashMap<Integer, Integer> Auguat08Table = new LinkedHashMap<Integer, Integer>();
		Auguat08Table.put(0, 0);
		Auguat08Table.put(1, 0);
		Auguat08Table.put(2, 0);
		Auguat08Table.put(3, 0);
		Auguat08Table.put(4, 1);
		Auguat08Table.put(5, 2);
		Auguat08Table.put(6, 3);
		Auguat08Table.put(10, 4);
		Auguat08Table.put(11, 5);
		Auguat08Table.put(12, 6);
		Auguat08Table.put(13, 7);
		Auguat08Table.put(14, 8);
		Auguat08Table.put(15, 9);
		Auguat08Table.put(16, 10);
		Auguat08Table.put(20, 11);
		Auguat08Table.put(21, 12);
		Auguat08Table.put(22, 13);
		Auguat08Table.put(23, 14);
		Auguat08Table.put(24, 15);
		Auguat08Table.put(25, 16);
		Auguat08Table.put(26, 17);
		Auguat08Table.put(30, 18);
		Auguat08Table.put(31, 19);
		Auguat08Table.put(32, 20);
		Auguat08Table.put(33, 21);
		Auguat08Table.put(34, 22);
		Auguat08Table.put(35, 23);
		Auguat08Table.put(36, 24);
		Auguat08Table.put(40, 25);
		Auguat08Table.put(41, 26);
		Auguat08Table.put(42, 27);
		Auguat08Table.put(43, 28);
		Auguat08Table.put(44, 29);
		Auguat08Table.put(45, 30);
		Auguat08Table.put(46, 31);
		Auguat08Table.put(50, 00);
		Auguat08Table.put(51, 00);
		Auguat08Table.put(52, 00);
		Auguat08Table.put(53, 00);
		Auguat08Table.put(54, 00);
		Auguat08Table.put(55, 00);
		Auguat08Table.put(56, 00);
		
		return Auguat08Table;
	}
	
	public static LinkedHashMap<Integer, Integer> september08table(){
		
		LinkedHashMap<Integer, Integer> sept08Table = new LinkedHashMap<Integer, Integer>();
		sept08Table.put(0, 1);
		sept08Table.put(1, 2);
		sept08Table.put(2, 3);
		sept08Table.put(3, 4);
		sept08Table.put(4, 5);
		sept08Table.put(5, 6);
		sept08Table.put(6, 7);
		sept08Table.put(10, 8);
		sept08Table.put(11, 9);
		sept08Table.put(12, 10);
		sept08Table.put(13, 11);
		sept08Table.put(14, 12);
		sept08Table.put(15, 13);
		sept08Table.put(16, 14);
		sept08Table.put(20, 15);
		sept08Table.put(21, 16);
		sept08Table.put(22, 17);
		sept08Table.put(23, 18);
		sept08Table.put(24, 19);
		sept08Table.put(25, 20);
		sept08Table.put(26, 21);
		sept08Table.put(30, 22);
		sept08Table.put(31, 23);
		sept08Table.put(32, 24);
		sept08Table.put(33, 25);
		sept08Table.put(34, 26);
		sept08Table.put(35, 27);
		sept08Table.put(36, 28);
		sept08Table.put(40, 29);
		sept08Table.put(41, 30);
		sept08Table.put(42, 00);
		sept08Table.put(43, 00);
		sept08Table.put(44, 00);
		sept08Table.put(45, 00);
		sept08Table.put(46, 00);
		sept08Table.put(50, 00);
		sept08Table.put(51, 00);
		sept08Table.put(52, 00);
		sept08Table.put(53, 00);
		sept08Table.put(54, 00);
		sept08Table.put(55, 00);
		sept08Table.put(56, 00);
		
		return sept08Table;
	}
	
	public static LinkedHashMap<Integer, Integer> october08table(){
		
		LinkedHashMap<Integer, Integer> october08Table = new LinkedHashMap<Integer, Integer>();
		october08Table.put(0, 0);
		october08Table.put(1, 0);
		october08Table.put(2, 1);
		october08Table.put(3, 2);
		october08Table.put(4, 3);
		october08Table.put(5, 4);
		october08Table.put(6, 5);
		october08Table.put(10, 6);
		october08Table.put(11, 7);
		october08Table.put(12, 8);
		october08Table.put(13, 9);
		october08Table.put(14, 10);
		october08Table.put(15, 11);
		october08Table.put(16, 12);
		october08Table.put(20, 13);
		october08Table.put(21, 14);
		october08Table.put(22, 15);
		october08Table.put(23, 16);
		october08Table.put(24, 17);
		october08Table.put(25, 18);
		october08Table.put(26, 19);
		october08Table.put(30, 20);
		october08Table.put(31, 21);
		october08Table.put(32, 22);
		october08Table.put(33, 23);
		october08Table.put(34, 24);
		october08Table.put(35, 25);
		october08Table.put(36, 26);
		october08Table.put(40, 27);
		october08Table.put(41, 28);
		october08Table.put(42, 29);
		october08Table.put(43, 30);
		october08Table.put(44, 31);
		october08Table.put(45, 00);
		october08Table.put(46, 00);
		october08Table.put(50, 00);
		october08Table.put(51, 00);
		october08Table.put(52, 00);
		october08Table.put(53, 00);
		october08Table.put(54, 00);
		october08Table.put(55, 00);
		october08Table.put(56, 00);
		
		return october08Table;
	}
	
	public static LinkedHashMap<Integer, Integer> november08table(){
		
		LinkedHashMap<Integer, Integer> nov08Table = new LinkedHashMap<Integer, Integer>();
		nov08Table.put(0, 0);
		nov08Table.put(1, 0);
		nov08Table.put(2, 0);
		nov08Table.put(3, 0);
		nov08Table.put(4, 0);
		nov08Table.put(5, 1);
		nov08Table.put(6, 2);
		nov08Table.put(10, 3);
		nov08Table.put(11, 4);
		nov08Table.put(12, 5);
		nov08Table.put(13, 6);
		nov08Table.put(14, 7);
		nov08Table.put(15, 8);
		nov08Table.put(16, 9);
		nov08Table.put(20, 10);
		nov08Table.put(21, 11);
		nov08Table.put(22, 12);
		nov08Table.put(23, 13);
		nov08Table.put(24, 14);
		nov08Table.put(25, 15);
		nov08Table.put(26, 16);
		nov08Table.put(30, 17);
		nov08Table.put(31, 18);
		nov08Table.put(32, 19);
		nov08Table.put(33, 20);
		nov08Table.put(34, 21);
		nov08Table.put(35, 22);
		nov08Table.put(36, 23);
		nov08Table.put(40, 24);
		nov08Table.put(41, 25);
		nov08Table.put(42, 26);
		nov08Table.put(43, 27);
		nov08Table.put(44, 28);
		nov08Table.put(45, 29);
		nov08Table.put(46, 30);
		nov08Table.put(50, 00);
		nov08Table.put(51, 00);
		nov08Table.put(52, 00);
		nov08Table.put(53, 00);
		nov08Table.put(54, 00);
		nov08Table.put(55, 00);
		nov08Table.put(56, 00);
		
		return nov08Table;
	}
	
	public static LinkedHashMap<Integer, Integer> december08table(){
		
		LinkedHashMap<Integer, Integer> dec08Table = new LinkedHashMap<Integer, Integer>();
		dec08Table.put(0, 1);
		dec08Table.put(1, 2);
		dec08Table.put(2, 3);
		dec08Table.put(3, 4);
		dec08Table.put(4, 5);
		dec08Table.put(5, 6);
		dec08Table.put(6, 7);
		dec08Table.put(10, 8);
		dec08Table.put(11, 9);
		dec08Table.put(12, 10);
		dec08Table.put(13, 11);
		dec08Table.put(14, 12);
		dec08Table.put(15, 13);
		dec08Table.put(16, 14);
		dec08Table.put(20, 15);
		dec08Table.put(21, 16);
		dec08Table.put(22, 17);
		dec08Table.put(23, 18);
		dec08Table.put(24, 19);
		dec08Table.put(25, 20);
		dec08Table.put(26, 21);
		dec08Table.put(30, 22);
		dec08Table.put(31, 23);
		dec08Table.put(32, 24);
		dec08Table.put(33, 25);
		dec08Table.put(34, 26);
		dec08Table.put(35, 27);
		dec08Table.put(36, 28);
		dec08Table.put(40, 29);
		dec08Table.put(41, 30);
		dec08Table.put(42, 31);
		dec08Table.put(43, 00);
		dec08Table.put(44, 00);
		dec08Table.put(45, 00);
		dec08Table.put(46, 00);
		dec08Table.put(50, 00);
		dec08Table.put(51, 00);
		dec08Table.put(52, 00);
		dec08Table.put(53, 00);
		dec08Table.put(54, 00);
		dec08Table.put(55, 00);
		dec08Table.put(56, 00);
		
		return dec08Table;
	}
	
	static Calendar jan2708CalStub() {
		Calendar calStub = new GregorianCalendar();
		calStub.set(2008, 1, 27, 0, 0, 0);
		return calStub;
	}
}
